home *** CD-ROM | disk | FTP | other *** search
/ Total Network Tools 2002 / NextStepPublishing-TotalNetworkTools2002-Win95.iso / Archive / Misc Servers / Zope.exe / PCGI_PUBLISHER.PY < prev    next >
Encoding:
Python Source  |  2000-09-07  |  14.0 KB  |  391 lines
  1. # PCGIPublisher.py
  2. # Persistent CGI Publisher - jeffbauer@bigfoot.com
  3. #
  4. # Copyright (c) 1998, Digital Creations, Fredericksburg, VA, USA.  All
  5. # rights reserved. This software includes contributions from Jeff Bauer.
  6. #
  7. # Redistribution and use in source and binary forms, with or without
  8. # modification, are permitted provided that the following conditions are
  9. # met:
  10. # 
  11. #   o Redistributions of source code must retain the above copyright
  12. #     notice, this list of conditions, and the disclaimer that follows.
  13. #
  14. #   o Redistributions in binary form must reproduce the above copyright
  15. #     notice, this list of conditions, and the following disclaimer in
  16. #     the documentation and/or other materials provided with the
  17. #     distribution.
  18. #
  19. #   o All advertising materials mentioning features or use of this
  20. #     software must display the following acknowledgement:
  21. #
  22. #       This product includes software developed by Digital Creations
  23. #       and its contributors.
  24. #
  25. #   o Neither the name of Digital Creations nor the names of its
  26. #     contributors may be used to endorse or promote products derived
  27. #     from this software without specific prior written permission.
  28. #
  29. #
  30. # THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS *AS IS* AND
  31. # ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  32. # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  33. # PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS
  34. # BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  35. # CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  36. # SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  37. # BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  38. # WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  39. # OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  40. # IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  41. #
  42. # 2.0 alpha4:
  43. #   - adds NT support, using INET sockets
  44. #   - added Mike Fletcher's Microsoft IIS hack, suggested by Amos Latteier
  45. #
  46. # 2.0 alpha3:
  47. #   - adds error checking
  48. #   - expands header to 10 bytes (extra byte defines an out-of-band msg)
  49. #
  50. # 2.0 alpha1:
  51. #   - add support for new PCGI_ directives
  52. #   - re-write module as a class, rather than a set of functions
  53.  
  54. __version__ = "2.0a4"
  55.  
  56. import string, sys, os
  57.  
  58. class PCGIPublisher:
  59.     def __init__(self, resource=None):
  60.         ### resources passed from the environment, info file or pcgi-wrapper
  61.         self.errorLogFile = None
  62.         self.hostname = None
  63.         self.port = 0
  64.         self.insertPath = None
  65.         self.moduleName = None
  66.         self.modulePath = None
  67.         self.socketFile = None
  68.         self.pidFile = None
  69.         self.swhome = None
  70.         self.sock = None
  71.  
  72.         ### bound imports ###
  73.         self.StringIO = None
  74.         self.publish_module = None
  75.  
  76.         ### other ###
  77.         self.bufsize = 8192
  78.         self.error = 0
  79.  
  80.         if resource is None:
  81.             self.getResources()
  82.         else:
  83.             self.resource = resource
  84.         self.initPCGI()
  85.  
  86.     def cleanup(self):
  87.         if self.socketFile:
  88.             import os
  89.             if os.path.exists(self.socketFile): 
  90.                 try:
  91.                     os.unlink(self.socketFile)
  92.                 except os.error:
  93.                     pass
  94.  
  95.     def getResources(self):
  96.         """
  97.         Obtain the publisher resources from the environment.  Done here
  98.         in a separate method to make it easy to override, because we may
  99.         not always and forever obtain our resources from the environment.
  100.         """
  101.         import os
  102.         self.resource = os.environ
  103.  
  104.     def fatalError(self, errmsg=''):
  105.         if self.errorLogFile:
  106.             import sys, traceback, StringIO
  107.             try:
  108.                 from time import asctime, localtime, time
  109.                 timeStamp = asctime(localtime(time()))
  110.             except ImportError:
  111.                 timeStamp = '???'
  112.             try:
  113.                 f = open(self.errorLogFile, 'a+')
  114.                 f.write("%s  %s\n" % (timeStamp, errmsg))
  115.                 if sys.exc_type != SystemExit:
  116.                     trace=StringIO.StringIO()
  117.                     traceback.print_exception(sys.exc_type,
  118.                                               sys.exc_value,
  119.                                               sys.exc_traceback,
  120.                                               None,
  121.                                               trace)
  122.                     f.write("  %s\n" % trace.getvalue())
  123.                 f.close()
  124.             except IOError:
  125.                 pass
  126.         self.cleanup()
  127.         self.error = 1
  128.  
  129.     def initPCGI(self):
  130.         import os
  131.         self.initPrincipia()
  132.         if self.resource.has_key('PCGI_ERROR_LOG'):
  133.             self.errorLogFile = self.resource['PCGI_ERROR_LOG']
  134.         if self.resource.has_key('PCGI_HOST'):
  135.             self.hostname = self.resource['PCGI_HOST']
  136.         if self.resource.has_key('PCGI_INSERT_PATH'):
  137.             self.insertPath = self.resource['PCGI_INSERT_PATH']
  138.         if self.resource.has_key('PCGI_MODULE_PATH'):
  139.             self.modulePath = self.resource['PCGI_MODULE_PATH']
  140.         if self.resource.has_key('PCGI_NAME'):
  141.             self.moduleName = self.resource['PCGI_NAME']
  142.         if self.resource.has_key('PCGI_PID_FILE'):
  143.             self.pidFile = self.resource['PCGI_PID_FILE']
  144.         if self.resource.has_key('PCGI_PORT'):
  145.             import string
  146.             try: self.port = string.atoi(self.resource['PCGI_PORT'])
  147.             except ValueError: pass
  148.         if self.resource.has_key('PCGI_SOCKET_FILE'):
  149.             self.socketFile = self.resource['PCGI_SOCKET_FILE']
  150.         self.insertSysPath()
  151.  
  152.         if not self.moduleName:
  153.             return self.fatalError("missing module name, try specifying PCGI_NAME")
  154.  
  155.         ### TODO: probably should make an attempt to import self.moduleName
  156.         ### to provide the user with earliest possible response.
  157.  
  158.         try:
  159.             from cStringIO import StringIO
  160.         except:
  161.             from StringIO import StringIO
  162.         self.StringIO = StringIO
  163.  
  164.         try:
  165.             from ZPublisher import publish_module
  166.         except ImportError:
  167.             try:
  168.                 from cgi_module_publisher import publish_module
  169.             except ImportError:
  170.                 return self.fatalError(
  171.                     "unable to import publish_module from ZPublisher")
  172.  
  173.         self.publish_module = publish_module
  174.  
  175.         if not self.pidFile:
  176.             return self.fatalError("missing pid file")
  177.  
  178.         ### create pid file ###
  179.         try:
  180.             f = open(self.pidFile, 'wb')
  181.             f.write(str(os.getpid()))
  182.             f.close()
  183.         except IOError:
  184.             return self.fatalError("unable to write to pid file: %s" % self.pidFile)
  185.         import socket
  186.         if not self.socketFile:
  187.             return self.fatalError("missing socket file")
  188.         if self.port:
  189.             if os.sep == '/':
  190.                 return self.fatalError("INET sockets not yet available on Unix")
  191.             if self.hostname is None:
  192.                 self.hostname = socket.gethostname()
  193.             try:
  194.                 self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  195.                 self.sock.bind((self.hostname, self.port))
  196.             except socket.error:
  197.                 return self.fatalError("error binding to socket: %s" % self.socketFile)
  198.             try:
  199.                 sf = open(self.socketFile, 'wb')
  200.                 sf.write("%s\n%s\n" % (self.hostname, self.port))
  201.                 sf.close()
  202.             except IOError:
  203.                 return self.fatalError("error attempting to write socket file: %s" % self.socketFile)
  204.         else:
  205.             try: os.unlink(self.socketFile)
  206.             except os.error: pass
  207.             try:
  208.                 self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
  209.                 self.sock.bind(self.socketFile)
  210.             except socket.error:
  211.                 return self.fatalError("error binding to socket: %s" % self.socketFile)
  212.             try: os.chmod(self.socketFile, 0777)
  213.             except os.error: pass
  214.  
  215.     def initPrincipia(self):
  216.         if self.resource.has_key('SOFTWARE_NAME'):
  217.             self.moduleName = self.resource['SOFTWARE_NAME']
  218.  
  219.     def insertSysPath(self, insertPath=None):
  220.         import os, sys, string
  221.         if insertPath is None: 
  222.             insertPath = self.insertPath
  223.         if insertPath:
  224.             sys.path[0:0]=string.split(insertPath,':')
  225.         elif self.resource.has_key('PCGI_WORKING_DIR'):
  226.             ### Note: PCGI_WORKING_DIR is a deprecated pcgi directive ###
  227.             workDir = self.resource['PCGI_WORKING_DIR']
  228.             while workDir[-1:]=='/' or workDir[-1:]=='\\':
  229.                 workDir=workDir[:-1]
  230.             sys.path[0:0]=[workDir]
  231.         else:
  232.             pass
  233.  
  234.         # The present assumption is that if the module path isn't in
  235.         # sys.path, we want it put there, even if the PCGI_INSERT_PATH 
  236.         # directive has been specified.
  237.         if self.modulePath:
  238.             d, s = os.path.split(self.modulePath)
  239.             if not d in sys.path:
  240.                 sys.path[0:0] = [d]
  241.             # If the moduleName is not known at this time, we make a
  242.             # reasonable guess based on the path.  It might behoove the
  243.             # user to explicitly specify PCGI_NAME, however.
  244.             if not self.moduleName:
  245.                 import string
  246.                 self.moduleName = string.splitfields(s,'.')[0]
  247.  
  248.     def handler(self, conn):
  249.         from string import split, join, atoi
  250.         hdr = conn.recv(10)
  251.  
  252.         size = atoi(hdr)
  253.         buff = []
  254.         while size > 0:
  255.             data = conn.recv(size)
  256.             size = size - len(data)
  257.             buff.append(data)
  258.  
  259.         ### XXX - Later: add out-of-band data handling ###
  260.         if (hdr[0] != '0'):
  261.             return
  262.  
  263.         env = {}
  264.         for i in filter(None, split(join(buff,''),'\000')):
  265.             e = split(i,'=')
  266.             if len(e) >= 2:
  267.                 env[e[0]] = join(e[1:],'=')
  268.             else:
  269.                 env[e[0]]=''
  270.         size = atoi(conn.recv(10))
  271.         if size > 1048576:
  272.             ### write large upload data to a file ###
  273.             from tempfile import TemporaryFile
  274.             stdin = TemporaryFile('w+b')
  275.             bufsize = self.bufsize
  276.             while size > 0:
  277.                 if size < bufsize: 
  278.                     bufsize=size
  279.                 data = conn.recv(bufsize)
  280.                 size = size - len(data)
  281.                 stdin.write(data)
  282.             stdin.seek(0,0)
  283.         else:
  284.             ### use StringIO for smaller data ###
  285.             buff = []
  286.             while size > 0:
  287.                 data = conn.recv(size)
  288.                 size = size-len(data)
  289.                 buff.append(data)
  290.             stdin = self.StringIO(join(buff,''))
  291.         stdout = self.StringIO()
  292.         stderr = self.StringIO()
  293.  
  294.         ### IIS hack to fix broken PATH_INFO
  295.         ### taken from Mike Fletcher's win_cgi_module_publisher
  296.         import string
  297.         if env.has_key('SERVER_SOFTWARE') and string.find(env['SERVER_SOFTWARE'],'Microsoft-IIS') != -1:
  298.             script = filter(None,string.split(string.strip(env['SCRIPT_NAME']),'/'))
  299.             path = filter(None,string.split(string.strip(env['PATH_INFO']),'/'))
  300.             env['PATH_INFO'] = string.join(path[len(script):],'/')
  301.  
  302.         try:
  303.             self.publish_module(self.moduleName,stdin=stdin,stdout=stdout,stderr=stderr,environ=env)
  304.         except:
  305.             self.fatalError("unable to publish module")
  306.  
  307.         stdin.close()
  308.         stdout=stdout.getvalue()
  309.         stderr=stderr.getvalue()
  310.  
  311.         stdout_len=len(stdout)
  312.         conn.send('%010d' % len(stdout))
  313.         to_send=stdout_len
  314.         if to_send > 0:
  315.             while 1:
  316.                 sent = conn.send(stdout)
  317.                 if sent == to_send:
  318.                     break
  319.                 else:
  320.                     to_send = to_send - sent
  321.                     stdout = stdout[sent:]
  322.                 
  323.         stderr_len=len(stderr)
  324.         conn.send('%010d' % stderr_len)
  325.         to_send=stderr_len
  326.         if to_send > 0:
  327.             while 1:
  328.                 sent = conn.send(stderr)
  329.                 if sent == to_send:
  330.                     break
  331.                 else:
  332.                     to_send = to_send - sent
  333.                     stderr = stderr[sent:]
  334.                     
  335.         conn.close()
  336.  
  337.     def listen(self):
  338.         """
  339.         Note to sub-classes:  Aside from the constructor, listen() should 
  340.         be the only method you *must* invoke.
  341.         """
  342.         if self.error:
  343.             return self.fatalError("attempt to listen after fatal error")
  344.  
  345.         import os, sys
  346.         if not self.sock:
  347.             return self.fatalError("no socket available")
  348.  
  349.         self.sock.listen(512)
  350.  
  351.         stdlog('stderr')
  352.         stdlog('stdout')
  353.  
  354.         while not self.error:
  355.             conn, accept = self.sock.accept()
  356.             try:
  357.                 self.handler(conn)
  358.             except socket.error:
  359.                 pass
  360.  
  361. def stdlog(name):
  362.     NAME=string.upper(name)+'_LOG'
  363.     if os.environ.has_key(NAME):
  364.         f=os.environ[NAME]
  365.     else:
  366.         f='/dev/null'
  367.     try: f=open(f,'a')
  368.     except: f=None
  369.     getattr(sys, name).close()
  370.     if f is not None: setattr(sys, name, f)
  371.  
  372. def main():
  373.     try:
  374.         import os, sys, string, traceback
  375.         pcgiPublisher = PCGIPublisher(os.environ)
  376.         if not pcgiPublisher.error:
  377.             pcgiPublisher.listen()
  378.     except ImportError:
  379.         print "Content-type: text/html"
  380.         print
  381.         print "PCGIPublisher catastrophic import error"
  382.  
  383. if __name__ == '__main__':
  384.     try: 
  385.         main()
  386.     finally:
  387.         import os
  388.         if os.environ.has_key('PCGI_SOCKET_FILE'):
  389.             try: os.unlink(os.environ['PCGI_SOCKET_FILE'])
  390.             except os.error: pass
  391.